import axios from 'axios'
import { ElMessage } from 'element-plus'

// 创建axios实例
const request = axios.create({
  baseURL: '/api', // 使用Vite代理
  timeout: 30000, // 增加超时时间
  withCredentials: true, // 支持跨域cookie
  headers: {
    'Content-Type': 'application/json'
  }
})

// 请求拦截器
request.interceptors.request.use(
  (config) => {
    // 🚀 P0网络修复：添加请求开始时间，用于监控耗时
    config._startTime = Date.now()

    // 🚀 P0网络修复：医疗级超时配置
    if (config.data instanceof FormData) {
      // 文件上传请求：60秒超时
      config.timeout = 60000
      console.log('📤 文件上传请求，设置60秒超时')
    } else {
      // 普通API请求：30秒超时
      config.timeout = 30000
      console.log('📤 普通API请求，设置30秒超时')
    }

    // 从localStorage直接获取token，避免在非组件上下文中使用useStore
    const token = localStorage.getItem('token')

    if (token) {
      // 检查token格式（简单的JWT格式验证）
      try {
        const parts = token.split('.')
        if (parts.length !== 3) {
          console.warn('⚠️ Token格式无效，清理旧token')
          localStorage.removeItem('token')
          localStorage.removeItem('user')
          return config
        }
        
        // 检查token是否过期
        const payload = JSON.parse(atob(parts[1]))
        const now = Math.floor(Date.now() / 1000)
        if (payload.exp && payload.exp < now) {
          console.warn('⚠️ Token已过期，清理旧token')
          localStorage.removeItem('token')
          localStorage.removeItem('user')
          return config
        }
        
        config.headers.Authorization = `Bearer ${token}`
      } catch (error) {
        console.warn('⚠️ Token解析失败，清理旧token:', error)
        localStorage.removeItem('token')
        localStorage.removeItem('user')
        return config
      }
    }

    // 🚀 P0网络修复：记录请求详情（不包含敏感数据）
    console.log('📤 发送请求:', {
      method: config.method?.toUpperCase(),
      url: config.url,
      hasData: !!config.data,
      isFormData: config.data instanceof FormData,
      timeout: config.timeout
    })

    return config
  },
  (error) => {
    console.error('❌ 请求拦截器错误:', error)
    return Promise.reject(error)
  }
)

// 🚀 P0网络修复：智能重试配置
const MAX_RETRY_ATTEMPTS = 2
const RETRY_DELAY = 1000 // 1秒

// 响应拦截器
request.interceptors.response.use(
  (response) => {
    const { data } = response

    // 🚀 P0网络修复：记录响应时间和状态
    const responseTime = Date.now() - (response.config._startTime || Date.now())
    console.log('✅ 请求响应:', {
      method: response.config.method?.toUpperCase(),
      url: response.config.url,
      status: response.status,
      responseTime: `${responseTime}ms`,
      dataSize: JSON.stringify(data).length
    })

    // 检查业务状态码
    if (data && data.success === false) {
      ElMessage.error(data.message || '请求失败')
      return Promise.reject(new Error(data.message || '请求失败'))
    }

    return data
  },
  async (error) => {
    const originalRequest = error.config

    // 🚀 P0网络修复：详细错误日志
    const responseTime = Date.now() - (originalRequest?._startTime || Date.now())
    console.error('❌ 请求错误:', {
      method: originalRequest?.method?.toUpperCase(),
      url: originalRequest?.url,
      message: error.message,
      code: error.code,
      status: error.response?.status,
      responseTime: `${responseTime}ms`,
      isFormData: originalRequest?.data instanceof FormData
    })

    // 🚀 P0网络修复：智能重试机制
    if (shouldRetry(error) && !originalRequest._retry && originalRequest._retryCount < MAX_RETRY_ATTEMPTS) {
      originalRequest._retry = true
      originalRequest._retryCount = (originalRequest._retryCount || 0) + 1

      console.log(`🔄 智能重试 (${originalRequest._retryCount}/${MAX_RETRY_ATTEMPTS}):`, {
        url: originalRequest.url,
        reason: error.code,
        delay: `${RETRY_DELAY}ms`
      })

      // 等待后重试
      await new Promise(resolve => setTimeout(resolve, RETRY_DELAY))

      return request(originalRequest)
    }

    // 处理CORS错误
    if (error.message && error.message.includes('CORS')) {
      ElMessage.error('跨域请求被阻止，请检查服务器配置')
      return Promise.reject(error)
    }

    // 处理HTTP状态码错误
    if (error.response) {
      const { status, data } = error.response

      switch (status) {
        case 400:
          ElMessage.error(data?.message || '请求参数错误')
          break
        case 401:
          ElMessage.error('登录已过期，请重新登录')
          // 清除本地存储的token
          localStorage.removeItem('token')
          localStorage.removeItem('user')
          // 不要自动跳转，让用户手动操作
          break
        case 403:
          if (data?.error === 'invalid signature' || data?.error?.includes('JWT')) {
            ElMessage.error('认证信息无效，请重新登录')
            // 清除无效的token
            localStorage.removeItem('token')
            localStorage.removeItem('user')
          } else {
            ElMessage.error('权限不足')
          }
          break
        case 404:
          ElMessage.error('请求的资源不存在')
          break
        case 413:
          ElMessage.error('上传文件过大，请控制在15MB以内')
          break
        case 422:
          ElMessage.error(data?.message || '请求参数验证失败')
          break
        case 429:
          ElMessage.error('请求过于频繁，请稍后再试')
          break
        case 500:
          ElMessage.error('服务器内部错误，请稍后重试')
          break
        case 502:
          ElMessage.error('网关错误，请稍后重试')
          break
        case 503:
          ElMessage.error('服务暂时不可用，请稍后重试')
          break
        case 504:
          ElMessage.error('网关超时，请稍后重试')
          break
        default:
          ElMessage.error(data?.message || `请求失败 (${status})`)
      }
    } else if (error.code === 'ECONNABORTED') {
      ElMessage.error(originalRequest?.data instanceof FormData
        ? '文件上传超时，请检查网络连接或重试'
        : '请求超时，请检查网络连接')
    } else if (error.code === 'ERR_NETWORK' || error.code === 'ECONNRESET') {
      ElMessage.error('网络连接失败，请检查服务器是否正常运行')
    } else {
      ElMessage.error(error.message || '请求失败，请稍后重试')
    }

    return Promise.reject(error)
  }
)

// 🚀 P0网络修复：判断是否应该重试
function shouldRetry(error) {
  // 网络相关错误可以重试
  if (error.code === 'ERR_NETWORK' ||
      error.code === 'ECONNRESET' ||
      error.code === 'ECONNABORTED' ||
      error.code === 'ETIMEDOUT') {
    return true
  }

  // 5xx服务器错误可以重试
  if (error.response && error.response.status >= 500 && error.response.status < 600) {
    return true
  }

  // 429 频率限制可以重试
  if (error.response && error.response.status === 429) {
    return true
  }

  return false
}

export default request